Interprocedural optimisation of regular parallel computations at runtime

This thesis concerns techniques for efficient runtime optimisation of regular parallel programs that are built from separate software components. High-quality, high-performance parallel software is frequently built from separately-written reusable software components such as functions from a library of parallel routines. Apart from the strong case from the software engineering point-of-view for constructing software in such a way, there is often also a large performance benefit in hand-optimising individual, frequently used routines. Hitherto, a problem with such libraries of separate software components has been that there is a performance penalty, both because of invocation and indirection overheads, and because opportunities for cross-component optimisations are missed. The techniques we describe in this thesis aim to reverse this disadvantage by making use of high-level abstract information about the components for performing cross-component optimisation. The key is to specify, generate and make use of metadata which characterise both data and software components, and to take advantage of run-time information. We propose a delayed evaluation, self-optimising (DESO) library of data-parallel numerical routines. Delayed evaluation allows us to capture the control-flow of a user program from within the library at runtime. When evaluation is eventually forced, we construct, at runtime, an optimised execution plan for the computation to be performed by the user program. The fact that our routines are purely data-parallel means that the key optimisation we have to perform is to determine parallel data placements which minimise the overall execution time of the parallel program. A key challenge in optimising at runtime is that optimisation itself must not be allowed to slow down the user program. We describe a range of techniques which permit us to fulfil this requirement: we work from optimised aggregate components which are not re-optimised at runtime; we use carefully constructed mathematical metadata that facilitate efficient optimisation; we re-use previously calculated optimisation results at runtime and we use an incremental optimisation strategy where we invest more optimisation time as optimisation contexts are encountered more frequently. We propose specific algorithms for optimising affine alignment of arrays in data parallel programs, for detecting opportunities to re-use previous optimisation results, and for optimising replication in data parallel programs. We have implemented our techniques in a parallel version of the widely used Basic Linear Algebra Subroutines (BLAS) library, and we provide initial performance results obtained with this library.